/*
     File:       Video.h
 
     Contains:   Video Driver Interfaces.
 
     Version:    QuickTime 7.3
 
     Copyright:  (c) 2007 (c) 1986-2001 by Apple Computer, Inc., all rights reserved
 
     Bugs?:      For bug reports, consult the following page on
                 the World Wide Web:
 
                     http://developer.apple.com/bugreporter/
 
*/
#ifndef __VIDEO__
#define __VIDEO__

#ifndef __QUICKDRAW__
#include "Quickdraw.h"
#endif




#if PRAGMA_ONCE
#pragma once
#endif

#if PRAGMA_IMPORT
#pragma import on
#endif

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
    #pragma pack(2)
#endif

enum {
  mBaseOffset                   = 1,    /*Id of mBaseOffset.*/
  mRowBytes                     = 2,    /*Video sResource parameter Id's */
  mBounds                       = 3,    /*Video sResource parameter Id's */
  mVersion                      = 4,    /*Video sResource parameter Id's */
  mHRes                         = 5,    /*Video sResource parameter Id's */
  mVRes                         = 6,    /*Video sResource parameter Id's */
  mPixelType                    = 7,    /*Video sResource parameter Id's */
  mPixelSize                    = 8,    /*Video sResource parameter Id's */
  mCmpCount                     = 9,    /*Video sResource parameter Id's */
  mCmpSize                      = 10,   /*Video sResource parameter Id's */
  mPlaneBytes                   = 11,   /*Video sResource parameter Id's */
  mVertRefRate                  = 14,   /*Video sResource parameter Id's */
  mVidParams                    = 1,    /*Video parameter block id.*/
  mTable                        = 2,    /*Offset to the table.*/
  mPageCnt                      = 3,    /*Number of pages*/
  mDevType                      = 4,    /*Device Type*/
  oneBitMode                    = 128,  /*Id of OneBitMode Parameter list.*/
  twoBitMode                    = 129,  /*Id of TwoBitMode Parameter list.*/
  fourBitMode                   = 130,  /*Id of FourBitMode Parameter list.*/
  eightBitMode                  = 131   /*Id of EightBitMode Parameter list.*/
};

enum {
  sixteenBitMode                = 132,  /*Id of SixteenBitMode Parameter list.*/
  thirtyTwoBitMode              = 133,  /*Id of ThirtyTwoBitMode Parameter list.*/
  firstVidMode                  = 128,  /*The new, better way to do the above. */
  secondVidMode                 = 129,  /* QuickDraw only supports six video */
  thirdVidMode                  = 130,  /* at this time.      */
  fourthVidMode                 = 131,
  fifthVidMode                  = 132,
  sixthVidMode                  = 133,
  spGammaDir                    = 64,
  spVidNamesDir                 = 65
};


/* csTimingFormat values in VDTimingInfo */
/* look in the declaration rom for timing info */
enum {
  kDeclROMtables                = FOUR_CHAR_CODE('decl'),
  kDetailedTimingFormat         = FOUR_CHAR_CODE('arba') /* Timing is a detailed timing*/
};

/* Size of a block of EDID (Extended Display Identification Data) */
enum {
  kDDCBlockSize                 = 128
};

/* ddcBlockType constants*/
enum {
  kDDCBlockTypeEDID             = 0     /* EDID block type. */
};

/* ddcFlags constants*/
enum {
  kDDCForceReadBit              = 0,    /* Force a new read of the EDID. */
  kDDCForceReadMask             = (1 << kDDCForceReadBit) /* Mask for kddcForceReadBit. */
};


/* Timing mode constants for Display Manager MultiMode support
    Corresponding   .h equates are in Video.h
                    .a equates are in Video.a
                    .r equates are in DepVideoEqu.r
    
    The second enum is the old names (for compatibility).
    The first enum is the new names.
*/
enum {
  timingInvalid                 = 0,    /*    Unknown timing... force user to confirm. */
  timingInvalid_SM_T24          = 8,    /*    Work around bug in SM Thunder24 card.*/
  timingApple_FixedRateLCD      = 42,   /*    Lump all fixed-rate LCDs into one category.*/
  timingApple_512x384_60hz      = 130,  /*  512x384  (60 Hz) Rubik timing. */
  timingApple_560x384_60hz      = 135,  /*  560x384  (60 Hz) Rubik-560 timing. */
  timingApple_640x480_67hz      = 140,  /*  640x480  (67 Hz) HR timing. */
  timingApple_640x400_67hz      = 145,  /*  640x400  (67 Hz) HR-400 timing. */
  timingVESA_640x480_60hz       = 150,  /*  640x480  (60 Hz) VGA timing. */
  timingVESA_640x480_72hz       = 152,  /*  640x480  (72 Hz) VGA timing. */
  timingVESA_640x480_75hz       = 154,  /*  640x480  (75 Hz) VGA timing. */
  timingVESA_640x480_85hz       = 158,  /*  640x480  (85 Hz) VGA timing. */
  timingGTF_640x480_120hz       = 159,  /*  640x480  (120 Hz) VESA Generalized Timing Formula */
  timingApple_640x870_75hz      = 160,  /*  640x870  (75 Hz) FPD timing.*/
  timingApple_640x818_75hz      = 165,  /*  640x818  (75 Hz) FPD-818 timing.*/
  timingApple_832x624_75hz      = 170,  /*  832x624  (75 Hz) GoldFish timing.*/
  timingVESA_800x600_56hz       = 180,  /*  800x600  (56 Hz) SVGA timing. */
  timingVESA_800x600_60hz       = 182,  /*  800x600  (60 Hz) SVGA timing. */
  timingVESA_800x600_72hz       = 184,  /*  800x600  (72 Hz) SVGA timing. */
  timingVESA_800x600_75hz       = 186,  /*  800x600  (75 Hz) SVGA timing. */
  timingVESA_800x600_85hz       = 188,  /*  800x600  (85 Hz) SVGA timing. */
  timingVESA_1024x768_60hz      = 190,  /* 1024x768  (60 Hz) VESA 1K-60Hz timing. */
  timingVESA_1024x768_70hz      = 200,  /* 1024x768  (70 Hz) VESA 1K-70Hz timing. */
  timingVESA_1024x768_75hz      = 204,  /* 1024x768  (75 Hz) VESA 1K-75Hz timing (very similar to timingApple_1024x768_75hz). */
  timingVESA_1024x768_85hz      = 208,  /* 1024x768  (85 Hz) VESA timing. */
  timingApple_1024x768_75hz     = 210,  /* 1024x768  (75 Hz) Apple 19" RGB. */
  timingApple_1152x870_75hz     = 220,  /* 1152x870  (75 Hz) Apple 21" RGB. */
  timingAppleNTSC_ST            = 230,  /*  512x384  (60 Hz, interlaced, non-convolved). */
  timingAppleNTSC_FF            = 232,  /*  640x480  (60 Hz, interlaced, non-convolved). */
  timingAppleNTSC_STconv        = 234,  /*  512x384  (60 Hz, interlaced, convolved). */
  timingAppleNTSC_FFconv        = 236,  /*  640x480  (60 Hz, interlaced, convolved). */
  timingApplePAL_ST             = 238,  /*  640x480  (50 Hz, interlaced, non-convolved). */
  timingApplePAL_FF             = 240,  /*  768x576  (50 Hz, interlaced, non-convolved). */
  timingApplePAL_STconv         = 242,  /*  640x480  (50 Hz, interlaced, convolved). */
  timingApplePAL_FFconv         = 244,  /*  768x576  (50 Hz, interlaced, convolved). */
  timingVESA_1280x960_75hz      = 250,  /* 1280x960  (75 Hz) */
  timingVESA_1280x960_60hz      = 252,  /* 1280x960  (60 Hz) */
  timingVESA_1280x960_85hz      = 254,  /* 1280x960  (85 Hz) */
  timingVESA_1280x1024_60hz     = 260,  /* 1280x1024 (60 Hz) */
  timingVESA_1280x1024_75hz     = 262,  /* 1280x1024 (75 Hz) */
  timingVESA_1280x1024_85hz     = 268,  /* 1280x1024 (85 Hz) */
  timingVESA_1600x1200_60hz     = 280,  /* 1600x1200 (60 Hz) VESA timing. */
  timingVESA_1600x1200_65hz     = 282,  /* 1600x1200 (65 Hz) VESA timing. */
  timingVESA_1600x1200_70hz     = 284,  /* 1600x1200 (70 Hz) VESA timing. */
  timingVESA_1600x1200_75hz     = 286,  /* 1600x1200 (75 Hz) VESA timing (pixel clock is 189.2 Mhz dot clock). */
  timingVESA_1600x1200_80hz     = 288,  /* 1600x1200 (80 Hz) VESA timing (pixel clock is 216>? Mhz dot clock) - proposed only. */
  timingVESA_1600x1200_85hz     = 289,  /* 1600x1200 (85 Hz) VESA timing (pixel clock is 229.5 Mhz dot clock). */
  timingVESA_1792x1344_60hz     = 296,  /* 1792x1344 (60 Hz) VESA timing (204.75 Mhz dot clock). */
  timingVESA_1792x1344_75hz     = 298,  /* 1792x1344 (75 Hz) VESA timing (261.75 Mhz dot clock). */
  timingVESA_1856x1392_60hz     = 300,  /* 1856x1392 (60 Hz) VESA timing (218.25 Mhz dot clock). */
  timingVESA_1856x1392_75hz     = 302,  /* 1856x1392 (75 Hz) VESA timing (288 Mhz dot clock). */
  timingVESA_1920x1440_60hz     = 304,  /* 1920x1440 (60 Hz) VESA timing (234 Mhz dot clock). */
  timingVESA_1920x1440_75hz     = 306,  /* 1920x1440 (75 Hz) VESA timing (297 Mhz dot clock). */
  timingSMPTE240M_60hz          = 400,  /* 60Hz V, 33.75KHz H, interlaced timing, 16:9 aspect, typical resolution of 1920x1035. */
  timingFilmRate_48hz           = 410,  /* 48Hz V, 25.20KHz H, non-interlaced timing, typical resolution of 640x480. */
  timingSony_1600x1024_76hz     = 500,  /* 1600x1024 (76 Hz) Sony timing (pixel clock is 170.447 Mhz dot clock). */
  timingSony_1920x1080_60hz     = 510,  /* 1920x1080 (60 Hz) Sony timing (pixel clock is 159.84 Mhz dot clock). */
  timingSony_1920x1080_72hz     = 520,  /* 1920x1080 (72 Hz) Sony timing (pixel clock is 216.023 Mhz dot clock). */
  timingSony_1920x1200_76hz     = 540,  /* 1900x1200 (76 Hz) Sony timing (pixel clock is 243.20 Mhz dot clock). */
  timingApple_0x0_0hz_Offline   = 550   /* Indicates that this timing will take the display off-line and remove it from the system. */
};


/* Deprecated timing names.*/
enum {
  timingApple12                 = timingApple_512x384_60hz,
  timingApple12x                = timingApple_560x384_60hz,
  timingApple13                 = timingApple_640x480_67hz,
  timingApple13x                = timingApple_640x400_67hz,
  timingAppleVGA                = timingVESA_640x480_60hz,
  timingApple15                 = timingApple_640x870_75hz,
  timingApple15x                = timingApple_640x818_75hz,
  timingApple16                 = timingApple_832x624_75hz,
  timingAppleSVGA               = timingVESA_800x600_56hz,
  timingApple1Ka                = timingVESA_1024x768_60hz,
  timingApple1Kb                = timingVESA_1024x768_70hz,
  timingApple19                 = timingApple_1024x768_75hz,
  timingApple21                 = timingApple_1152x870_75hz,
  timingSony_1900x1200_74hz     = 530,  /* 1900x1200 (74 Hz) Sony timing (pixel clock is 236.25 Mhz dot clock). */
  timingSony_1900x1200_76hz     = timingSony_1920x1200_76hz /* 1900x1200 (76 Hz) Sony timing (pixel clock is 245.48 Mhz dot clock). */
};

/* csConnectFlags values in VDDisplayConnectInfo */
enum {
  kAllModesValid                = 0,    /* All modes not trimmed by primary init are good close enough to try */
  kAllModesSafe                 = 1,    /* All modes not trimmed by primary init are know to be safe */
  kReportsTagging               = 2,    /* Can detect tagged displays (to identify smart monitors) */
  kHasDirectConnection          = 3,    /* True implies that driver can talk directly to device (e.g. serial data link via sense lines) */
  kIsMonoDev                    = 4,    /* Says whether there's an RGB (0) or Monochrome (1) connection. */
  kUncertainConnection          = 5,    /* There may not be a display (no sense lines?). */
  kTaggingInfoNonStandard       = 6,    /* Set when csConnectTaggedType/csConnectTaggedData are non-standard (i.e., not the Apple CRT sense codes). */
  kReportsDDCConnection         = 7,    /* Card can do ddc (set kHasDirectConnect && kHasDDCConnect if you actually found a ddc display). */
  kHasDDCConnection             = 8,    /* Card has ddc connect now. */
  kConnectionInactive           = 9,    /* Set when the connection is NOT currently active (generally used in a multiconnection environment). */
  kDependentConnection          = 10,   /* Set when some ascpect of THIS connection depends on another (will generally be set in a kModeSimulscan environment). */
  kBuiltInConnection            = 11,   /* Set when connection is KNOWN to be built-in (this is not the same as kHasDirectConnection). */
  kOverrideConnection           = 12,   /* Set when the reported connection is not the true one, but is one that has been forced through a SetConnection call */
  kFastCheckForDDC              = 13,   /* Set when all 3 are true: 1) sense codes indicate DDC display could be attached 2) attempted fast check 3) DDC failed */
  kReportsHotPlugging           = 14    /* Detects and reports hot pluggging on connector (via VSL also implies DDC will be up to date w/o force read) */
};


/* csDisplayType values in VDDisplayConnectInfo */
enum {
  kUnknownConnect               = 1,    /* Not sure how we'll use this, but seems like a good idea. */
  kPanelConnect                 = 2,    /* For use with fixed-in-place LCD panels. */
  kPanelTFTConnect              = 2,    /* Alias for kPanelConnect */
  kFixedModeCRTConnect          = 3,    /*  For use with fixed-mode (i.e., very limited range) displays. */
  kMultiModeCRT1Connect         = 4,    /* 320x200 maybe, 12" maybe, 13" (default), 16" certain, 19" maybe, 21" maybe */
  kMultiModeCRT2Connect         = 5,    /* 320x200 maybe, 12" maybe, 13" certain, 16" (default), 19" certain, 21" maybe */
  kMultiModeCRT3Connect         = 6,    /* 320x200 maybe, 12" maybe, 13" certain, 16" certain, 19" default, 21" certain */
  kMultiModeCRT4Connect         = 7,    /* Expansion to large multi mode (not yet used) */
  kModelessConnect              = 8,    /* Expansion to modeless model (not yet used) */
  kFullPageConnect              = 9,    /* 640x818 (to get 8bpp in 512K case) and 640x870 (these two only) */
  kVGAConnect                   = 10,   /* 640x480 VGA default -- question everything else */
  kNTSCConnect                  = 11,   /* NTSC ST (default), FF, STconv, FFconv */
  kPALConnect                   = 12,   /* PAL ST (default), FF, STconv, FFconv */
  kHRConnect                    = 13,   /* Straight-6 connect -- 640x480 and 640x400 (to get 8bpp in 256K case) (these two only) */
  kPanelFSTNConnect             = 14,   /* For use with fixed-in-place LCD FSTN (aka "Supertwist") panels */
  kMonoTwoPageConnect           = 15,   /* 1152x870 Apple color two-page display */
  kColorTwoPageConnect          = 16,   /* 1152x870 Apple B&W two-page display */
  kColor16Connect               = 17,   /* 832x624 Apple B&W two-page display */
  kColor19Connect               = 18,   /* 1024x768 Apple B&W two-page display */
  kGenericCRT                   = 19,   /* Indicates nothing except that connection is CRT in nature. */
  kGenericLCD                   = 20,   /* Indicates nothing except that connection is LCD in nature. */
  kDDCConnect                   = 21,   /* DDC connection, always set kHasDDCConnection */
  kNoConnect                    = 22    /* No display is connected - load sensing or similar level of hardware detection is assumed (used by resident drivers that support hot plugging when nothing is currently connected) */
};

/* csTimingFlags values in VDTimingInfoRec */
enum {
  kModeValid                    = 0,    /* Says that this mode should NOT be trimmed. */
  kModeSafe                     = 1,    /* This mode does not need confirmation */
  kModeDefault                  = 2,    /* This is the default mode for this type of connection */
  kModeShowNow                  = 3,    /* This mode should always be shown (even though it may require a confirm) */
  kModeNotResize                = 4,    /* This mode should not be used to resize the display (eg. mode selects a different connector on card) */
  kModeRequiresPan              = 5,    /* This mode has more pixels than are actually displayed */
  kModeInterlaced               = 6,    /* This mode is interlaced (single pixel lines look bad). */
  kModeShowNever                = 7,    /* This mode should not be shown in the user interface. */
  kModeSimulscan                = 8,    /* Indicates that more than one display connection can be driven from a single framebuffer controller. */
  kModeNotPreset                = 9,    /* Indicates that the timing is not a factory preset for the current display (geometry may need correction) */
  kModeBuiltIn                  = 10,   /* Indicates that the display mode is for the built-in connect only (on multiconnect devices like the PB 3400) Only the driver is quieried */
  kModeStretched                = 11    /* Indicates that the display mode will be stretched/distorted to match the display aspect ratio */
};

/* csDepthFlags in VDVideoParametersInfoRec */
enum {
  kDepthDependent               = 0     /* Says that this depth mode may cause dependent changes in other framebuffers (and . */
};

/* csResolutionFlags bit flags for VDResolutionInfoRec */
enum {
  kResolutionHasMultipleDepthSizes = 0  /* Says that this mode has different csHorizontalPixels, csVerticalLines at different depths (usually slightly larger at lower depths) */
};


enum {
                                        /*    Power Mode constants for VDPowerStateRec.powerState.  Note the numeric order does not match the power state order */
  kAVPowerOff                   = 0,    /* Power fully off*/
  kAVPowerStandby               = 1,
  kAVPowerSuspend               = 2,
  kAVPowerOn                    = 3,
  kHardwareSleep                = 128,
  kHardwareWake                 = 129,
  kHardwareWakeFromSuspend      = 130,
  kHardwareWakeToDoze           = 131,
  kHardwareWakeToDozeFromSuspend = 132
};

enum {
                                        /*    Power Mode masks and bits for VDPowerStateRec.powerFlags.  */
  kPowerStateNeedsRefresh       = 0,    /* When leaving this power mode, a display will need refreshing   */
  kPowerStateSleepAwareBit      = 1,    /* if gestaltPCCardDockingSelectorFix, Docking mgr checks this bit before checking kPowerStateSleepAllowedBit */
  kPowerStateSleepForbiddenBit  = 2,    /* if kPowerStateSleepAwareBit, Docking mgr checks this bit before sleeping */
  kPowerStateSleepCanPowerOffBit = 3,   /* supports power down sleep (ie PCI power off)*/
  kPowerStateSleepNoDPMSBit     = 4,    /* Bug #2425210.  Do not use DPMS with this display.*/
  kPowerStateSleepWaketoDozeBit = 5,    /* Supports Wake to Doze */
  kPowerStateNeedsRefreshMask   = (1L << kPowerStateNeedsRefresh),
  kPowerStateSleepAwareMask     = (1L << kPowerStateSleepAwareBit),
  kPowerStateSleepForbiddenMask = (1L << kPowerStateSleepForbiddenBit),
  kPowerStateSleepCanPowerOffMask = (1L << kPowerStateSleepCanPowerOffBit),
  kPowerStateSleepNoDPMSMask    = (1L << kPowerStateSleepNoDPMSBit),
  kPowerStateSleepWaketoDozeMask = (1L << kPowerStateSleepWaketoDozeBit)
};


enum {
                                        /* Control Codes */
  cscReset                      = 0,
  cscKillIO                     = 1,
  cscSetMode                    = 2,
  cscSetEntries                 = 3,
  cscSetGamma                   = 4,
  cscGrayPage                   = 5,
  cscGrayScreen                 = 5,
  cscSetGray                    = 6,
  cscSetInterrupt               = 7,
  cscDirectSetEntries           = 8,
  cscSetDefaultMode             = 9,
  cscSwitchMode                 = 10,   /* Takes a VDSwitchInfoPtr */
  cscSetSync                    = 11,   /* Takes a VDSyncInfoPtr */
  cscSavePreferredConfiguration = 16,   /* Takes a VDSwitchInfoPtr */
  cscSetHardwareCursor          = 22,   /* Takes a VDSetHardwareCursorPtr */
  cscDrawHardwareCursor         = 23,   /* Takes a VDDrawHardwareCursorPtr */
  cscSetConvolution             = 24,   /* Takes a VDConvolutionInfoPtr */
  cscSetPowerState              = 25,   /* Takes a VDPowerStatePtr */
  cscPrivateControlCall         = 26,   /* Takes a VDPrivateSelectorDataPtr */
  cscSetMultiConnect            = 28,   /* Takes a VDMultiConnectInfoPtr */
  cscSetClutBehavior            = 29,   /* Takes a VDClutBehavior */
  cscSetDetailedTiming          = 31,   /* Takes a VDDetailedTimingPtr */
  cscDoCommunication            = 33,   /* Takes a VDCommunicationPtr */
  cscProbeConnection            = 34,   /* Takes nil pointer (may generate a kFBConnectInterruptServiceType service interrupt)*/
  cscUnusedCall                 = 127   /* This call used to expend the scrn resource.  Its imbedded data contains more control info */
};

enum {
                                        /* Status Codes */
  cscGetMode                    = 2,
  cscGetEntries                 = 3,
  cscGetPageCnt                 = 4,
  cscGetPages                   = 4,    /* This is what C&D 2 calls it. */
  cscGetPageBase                = 5,
  cscGetBaseAddr                = 5,    /* This is what C&D 2 calls it. */
  cscGetGray                    = 6,
  cscGetInterrupt               = 7,
  cscGetGamma                   = 8,
  cscGetDefaultMode             = 9,
  cscGetCurMode                 = 10,   /* Takes a VDSwitchInfoPtr */
  cscGetSync                    = 11,   /* Takes a VDSyncInfoPtr */
  cscGetConnection              = 12,   /* Return information about the connection to the display */
  cscGetModeTiming              = 13,   /* Return timing info for a mode */
  cscGetModeBaseAddress         = 14,   /* Return base address information about a particular mode */
  cscGetScanProc                = 15,   /* QuickTime scan chasing routine */
  cscGetPreferredConfiguration  = 16,   /* Takes a VDSwitchInfoPtr */
  cscGetNextResolution          = 17,   /* Takes a VDResolutionInfoPtr */
  cscGetVideoParameters         = 18,   /* Takes a VDVideoParametersInfoPtr */
  cscGetGammaInfoList           = 20,   /* Takes a VDGetGammaListPtr */
  cscRetrieveGammaTable         = 21,   /* Takes a VDRetrieveGammaPtr */
  cscSupportsHardwareCursor     = 22,   /* Takes a VDSupportsHardwareCursorPtr */
  cscGetHardwareCursorDrawState = 23,   /* Takes a VDHardwareCursorDrawStatePtr */
  cscGetConvolution             = 24,   /* Takes a VDConvolutionInfoPtr */
  cscGetPowerState              = 25,   /* Takes a VDPowerStatePtr */
  cscPrivateStatusCall          = 26,   /* Takes a VDPrivateSelectorDataPtr */
  cscGetDDCBlock                = 27,   /* Takes a VDDDCBlockPtr  */
  cscGetMultiConnect            = 28,   /* Takes a VDMultiConnectInfoPtr */
  cscGetClutBehavior            = 29,   /* Takes a VDClutBehaviorPtr */
  cscGetTimingRanges            = 30,   /* Takes a VDDisplayTimingRangePtr */
  cscGetDetailedTiming          = 31,   /* Takes a VDDetailedTimingPtr */
  cscGetCommunicationInfo       = 32    /* Takes a VDCommunicationInfoPtr */
};

/* Bit definitions for the Get/Set Sync call*/
enum {
  kDisableHorizontalSyncBit     = 0,
  kDisableVerticalSyncBit       = 1,
  kDisableCompositeSyncBit      = 2,
  kEnableSyncOnBlue             = 3,
  kEnableSyncOnGreen            = 4,
  kEnableSyncOnRed              = 5,
  kNoSeparateSyncControlBit     = 6,
  kTriStateSyncBit              = 7,
  kHorizontalSyncMask           = 0x01,
  kVerticalSyncMask             = 0x02,
  kCompositeSyncMask            = 0x04,
  kDPMSSyncMask                 = 0x07,
  kTriStateSyncMask             = 0x80,
  kSyncOnBlueMask               = 0x08,
  kSyncOnGreenMask              = 0x10,
  kSyncOnRedMask                = 0x20,
  kSyncOnMask                   = 0x38
};

enum {
                                        /*    Power Mode constants for translating DPMS modes to Get/SetSync calls.  */
  kDPMSSyncOn                   = 0,
  kDPMSSyncStandby              = 1,
  kDPMSSyncSuspend              = 2,
  kDPMSSyncOff                  = 7
};

/* Bit definitions for the Get/Set Convolution call*/
enum {
  kConvolved                    = 0,
  kLiveVideoPassThru            = 1,
  kConvolvedMask                = 0x01,
  kLiveVideoPassThruMask        = 0x02
};


struct VPBlock {
  long                vpBaseOffset;           /*Offset to page zero of video RAM (From minorBaseOS).*/
  short               vpRowBytes;             /*Width of each row of video memory.*/
  Rect                vpBounds;               /*BoundsRect for the video display (gives dimensions).*/
  short               vpVersion;              /*PixelMap version number.*/
  short               vpPackType;
  long                vpPackSize;
  long                vpHRes;                 /*Horizontal resolution of the device (pixels per inch).*/
  long                vpVRes;                 /*Vertical resolution of the device (pixels per inch).*/
  short               vpPixelType;            /*Defines the pixel type.*/
  short               vpPixelSize;            /*Number of bits in pixel.*/
  short               vpCmpCount;             /*Number of components in pixel.*/
  short               vpCmpSize;              /*Number of bits per component*/
  long                vpPlaneBytes;           /*Offset from one plane to the next.*/
};
typedef struct VPBlock                  VPBlock;
typedef VPBlock *                       VPBlockPtr;
struct VDEntryRecord {
  Ptr                 csTable;                /*(long) pointer to color table entry=value, r,g,b:INTEGER*/
};
typedef struct VDEntryRecord            VDEntryRecord;
typedef VDEntryRecord *                 VDEntRecPtr;
/* Parm block for SetGray control call */
struct VDGrayRecord {
  Boolean             csMode;                 /*Same as GDDevType value (0=color, 1=mono)*/
  SInt8               filler;
};
typedef struct VDGrayRecord             VDGrayRecord;
typedef VDGrayRecord *                  VDGrayPtr;
/* Parm block for SetInterrupt call */
struct VDFlagRecord {
  SInt8               csMode;
  SInt8               filler;
};
typedef struct VDFlagRecord             VDFlagRecord;
typedef VDFlagRecord *                  VDFlagRecPtr;
/* Parm block for SetEntries control call */
struct VDSetEntryRecord {
  ColorSpec *         csTable;                /*Pointer to an array of color specs*/
  short               csStart;                /*Which spec in array to start with, or -1*/
  short               csCount;                /*Number of color spec entries to set*/
};
typedef struct VDSetEntryRecord         VDSetEntryRecord;
typedef VDSetEntryRecord *              VDSetEntryPtr;
/* Parm block for SetGamma control call */
struct VDGammaRecord {
  Ptr                 csGTable;               /*pointer to gamma table*/
};
typedef struct VDGammaRecord            VDGammaRecord;
typedef VDGammaRecord *                 VDGamRecPtr;
struct VDBaseAddressInfoRec {
  long                csDevData;              /* LONGINT - (long) timing mode */
  long                csDevBase;              /* LONGINT - (long) base address of the mode */
  short               csModeReserved;         /* INTEGER - (short) will some day be the depth */
  long                csModeBase;             /* LONGINT - (long) reserved */
};
typedef struct VDBaseAddressInfoRec     VDBaseAddressInfoRec;
typedef VDBaseAddressInfoRec *          VDBaseAddressInfoPtr;
struct VDSwitchInfoRec {
  unsigned short      csMode;                 /*(word) mode depth*/
  unsigned long       csData;                 /*(long) functional sResource of mode*/
  unsigned short      csPage;                 /*(word) page to switch in*/
  Ptr                 csBaseAddr;             /*(long) base address of page (return value)*/
  unsigned long       csReserved;             /*(long) Reserved (set to 0) */
};
typedef struct VDSwitchInfoRec          VDSwitchInfoRec;
typedef VDSwitchInfoRec *               VDSwitchInfoPtr;
struct VDTimingInfoRec {
  unsigned long       csTimingMode;           /* LONGINT - (long) timing mode (a la InitGDevice) */
  unsigned long       csTimingReserved;       /* LONGINT - (long) reserved */
  unsigned long       csTimingFormat;         /* LONGINT - (long) what format is the timing info */
  unsigned long       csTimingData;           /* LONGINT - (long) data supplied by driver */
  unsigned long       csTimingFlags;          /* LONGINT - (long) mode within device */
};
typedef struct VDTimingInfoRec          VDTimingInfoRec;
typedef VDTimingInfoRec *               VDTimingInfoPtr;
struct VDDisplayConnectInfoRec {
  unsigned short      csDisplayType;          /* INTEGER - (word) Type of display connected */
  unsigned char       csConnectTaggedType;    /* BYTE - type of tagging */
  unsigned char       csConnectTaggedData;    /* BYTE - tagging data */
  unsigned long       csConnectFlags;         /* LONGINT - (long) tell us about the connection */
  unsigned long       csDisplayComponent;     /* LONGINT - (long) if the card has a direct connection to the display, it returns the display component here (FUTURE) */
  unsigned long       csConnectReserved;      /* LONGINT - (long) reserved */
};
typedef struct VDDisplayConnectInfoRec  VDDisplayConnectInfoRec;
typedef VDDisplayConnectInfoRec *       VDDisplayConnectInfoPtr;
struct VDMultiConnectInfoRec {
  unsigned long       csDisplayCountOrNumber; /* For GetMultiConnect, returns count n of 1..n connections; otherwise, indicates the ith connection.*/
  VDDisplayConnectInfoRec  csConnectInfo;     /* Standard VDDisplayConnectionInfo for connection i.*/
};
typedef struct VDMultiConnectInfoRec    VDMultiConnectInfoRec;
typedef VDMultiConnectInfoRec *         VDMultiConnectInfoPtr;
/* RawSenseCode
    This abstract data type is not exactly abstract.  Rather, it is merely enumerated constants
    for the possible raw sense code values when 'standard' sense code hardware is implemented.

    For 'standard' sense code hardware, the raw sense is obtained as follows:
        o Instruct the frame buffer controller NOT to actively drive any of the monitor sense lines
        o Read the state of the monitor sense lines 2, 1, and 0.  (2 is the MSB, 0 the LSB)

    IMPORTANT Note: 
    When the 'kTaggingInfoNonStandard' bit of 'csConnectFlags' is FALSE, then these constants 
    are valid 'csConnectTaggedType' values in 'VDDisplayConnectInfo' 

*/
typedef unsigned char                   RawSenseCode;
enum {
  kRSCZero                      = 0,
  kRSCOne                       = 1,
  kRSCTwo                       = 2,
  kRSCThree                     = 3,
  kRSCFour                      = 4,
  kRSCFive                      = 5,
  kRSCSix                       = 6,
  kRSCSeven                     = 7
};


/* ExtendedSenseCode
    This abstract data type is not exactly abstract.  Rather, it is merely enumerated constants
    for the values which are possible when the extended sense algorithm is applied to hardware
    which implements 'standard' sense code hardware.

    For 'standard' sense code hardware, the extended sense code algorithm is as follows:
    (Note:  as described here, sense line 'A' corresponds to '2', 'B' to '1', and 'C' to '0')
        o Drive sense line 'A' low and read the values of 'B' and 'C'.  
        o Drive sense line 'B' low and read the values of 'A' and 'C'.
        o Drive sense line 'C' low and read the values of 'A' and 'B'.

    In this way, a six-bit number of the form BC/AC/AB is generated. 

    IMPORTANT Note: 
    When the 'kTaggingInfoNonStandard' bit of 'csConnectFlags' is FALSE, then these constants 
    are valid 'csConnectTaggedData' values in 'VDDisplayConnectInfo' 

*/
typedef unsigned char                   ExtendedSenseCode;
enum {
  kESCZero21Inch                = 0x00, /* 21" RGB                     */
  kESCOnePortraitMono           = 0x14, /* Portrait Monochrome              */
  kESCTwo12Inch                 = 0x21, /* 12" RGB                    */
  kESCThree21InchRadius         = 0x31, /* 21" RGB (Radius)               */
  kESCThree21InchMonoRadius     = 0x34, /* 21" Monochrome (Radius)           */
  kESCThree21InchMono           = 0x35, /* 21" Monochrome               */
  kESCFourNTSC                  = 0x0A, /* NTSC                     */
  kESCFivePortrait              = 0x1E, /* Portrait RGB              */
  kESCSixMSB1                   = 0x03, /* MultiScan Band-1 (12" thru 1Six")  */
  kESCSixMSB2                   = 0x0B, /* MultiScan Band-2 (13" thru 19")       */
  kESCSixMSB3                   = 0x23, /* MultiScan Band-3 (13" thru 21")       */
  kESCSixStandard               = 0x2B, /* 13"/14" RGB or 12" Monochrome   */
  kESCSevenPAL                  = 0x00, /* PAL                        */
  kESCSevenNTSC                 = 0x14, /* NTSC                     */
  kESCSevenVGA                  = 0x17, /* VGA                        */
  kESCSeven16Inch               = 0x2D, /* 16" RGB (GoldFish)               */
  kESCSevenPALAlternate         = 0x30, /* PAL (Alternate)                */
  kESCSeven19Inch               = 0x3A, /* Third-Party 19"                 */
  kESCSevenDDC                  = 0x3E, /* DDC display                   */
  kESCSevenNoDisplay            = 0x3F  /* No display connected           */
};

/* DepthMode
    This abstract data type is used to to reference RELATIVE pixel depths.
    Its definition is largely derived from its past usage, analogous to 'xxxVidMode'

    Bits per pixel DOES NOT directly map to 'DepthMode'  For example, on some
    graphics hardware, 'kDepthMode1' may represent 1 BPP, whereas on other
    hardware, 'kDepthMode1' may represent 8BPP.

    DepthMode IS considered to be ordinal, i.e., operations such as <, >, ==, etc.
    behave as expected.  The values of the constants which comprise the set are such
    that 'kDepthMode4 < kDepthMode6' behaves as expected.
*/
typedef unsigned short                  DepthMode;
enum {
  kDepthMode1                   = 128,
  kDepthMode2                   = 129,
  kDepthMode3                   = 130,
  kDepthMode4                   = 131,
  kDepthMode5                   = 132,
  kDepthMode6                   = 133
};

enum {
  kFirstDepthMode               = 128,  /* These constants are obsolete, and just included    */
  kSecondDepthMode              = 129,  /* for clients that have converted to the above     */
  kThirdDepthMode               = 130,  /* kDepthModeXXX constants.                */
  kFourthDepthMode              = 131,
  kFifthDepthMode               = 132,
  kSixthDepthMode               = 133
};


struct VDPageInfo {
  short               csMode;                 /*(word) mode within device*/
  long                csData;                 /*(long) data supplied by driver*/
  short               csPage;                 /*(word) page to switch in*/
  Ptr                 csBaseAddr;             /*(long) base address of page*/
};
typedef struct VDPageInfo               VDPageInfo;
typedef VDPageInfo *                    VDPgInfoPtr;
struct VDSizeInfo {
  short               csHSize;                /*(word) desired/returned h size*/
  short               csHPos;                 /*(word) desired/returned h position*/
  short               csVSize;                /*(word) desired/returned v size*/
  short               csVPos;                 /*(word) desired/returned v position*/
};
typedef struct VDSizeInfo               VDSizeInfo;
typedef VDSizeInfo *                    VDSzInfoPtr;
struct VDSettings {
  short               csParamCnt;             /*(word) number of params*/
  short               csBrightMax;            /*(word) max brightness*/
  short               csBrightDef;            /*(word) default brightness*/
  short               csBrightVal;            /*(word) current brightness*/
  short               csCntrstMax;            /*(word) max contrast*/
  short               csCntrstDef;            /*(word) default contrast*/
  short               csCntrstVal;            /*(word) current contrast*/
  short               csTintMax;              /*(word) max tint*/
  short               csTintDef;              /*(word) default tint*/
  short               csTintVal;              /*(word) current tint*/
  short               csHueMax;               /*(word) max hue*/
  short               csHueDef;               /*(word) default hue*/
  short               csHueVal;               /*(word) current hue*/
  short               csHorizDef;             /*(word) default horizontal*/
  short               csHorizVal;             /*(word) current horizontal*/
  short               csHorizMax;             /*(word) max horizontal*/
  short               csVertDef;              /*(word) default vertical*/
  short               csVertVal;              /*(word) current vertical*/
  short               csVertMax;              /*(word) max vertical*/
};
typedef struct VDSettings               VDSettings;
typedef VDSettings *                    VDSettingsPtr;
struct VDDefMode {
  UInt8               csID;
  SInt8               filler;
};
typedef struct VDDefMode                VDDefMode;
typedef VDDefMode *                     VDDefModePtr;
struct VDSyncInfoRec {
  UInt8               csMode;
  UInt8               csFlags;
};
typedef struct VDSyncInfoRec            VDSyncInfoRec;
typedef VDSyncInfoRec *                 VDSyncInfoPtr;
typedef UInt32                          AVIDType;
typedef AVIDType                        DisplayIDType;
typedef UInt32                          DisplayModeID;
typedef UInt32                          VideoDeviceType;
typedef UInt32                          GammaTableID;
/*
   All displayModeID values from 0x80000000 to 0xFFFFFFFF and 0x00
   are reserved for Apple Computer.
*/
/* Constants for the cscGetNextResolution call */
enum {
  kDisplayModeIDCurrent         = 0x00, /* Reference the Current DisplayModeID */
  kDisplayModeIDInvalid         = (long)0xFFFFFFFF, /* A bogus DisplayModeID in all cases */
  kDisplayModeIDFindFirstResolution = (long)0xFFFFFFFE, /* Used in cscGetNextResolution to reset iterator */
  kDisplayModeIDNoMoreResolutions = (long)0xFFFFFFFD, /* Used in cscGetNextResolution to indicate End Of List */
  kDisplayModeIDFindFirstProgrammable = (long)0xFFFFFFFC, /* Used in cscGetNextResolution to find unused programmable timing */
  kDisplayModeIDBootProgrammable = (long)0xFFFFFFFB, /* This is the ID given at boot time by the OF driver to a programmable timing */
  kDisplayModeIDReservedBase    = (long)0x80000000 /* Lowest (unsigned) DisplayModeID reserved by Apple */
};

/* Constants for the GetGammaInfoList call */
enum {
  kGammaTableIDFindFirst        = (long)0xFFFFFFFE, /* Get the first gamma table ID */
  kGammaTableIDNoMoreTables     = (long)0xFFFFFFFD, /* Used to indicate end of list */
  kGammaTableIDSpecific         = 0x00  /* Return the info for the given table id */
};

/* Constants for GetMultiConnect call*/
enum {
  kGetConnectionCount           = (long)0xFFFFFFFF, /* Used to get the number of possible connections in a "multi-headed" framebuffer environment.*/
  kActivateConnection           = (0 << kConnectionInactive), /* Used for activating a connection (csConnectFlags value).*/
  kDeactivateConnection         = (1 << kConnectionInactive) /* Used for deactivating a connection (csConnectFlags value.)*/
};

/* VDCommunicationRec.csBusID values*/
enum {
  kVideoDefaultBus              = 0
};


/* VDCommunicationInfoRec.csBusType values*/
enum {
  kVideoBusTypeInvalid          = 0,
  kVideoBusTypeI2C              = 1
};


/* VDCommunicationRec.csSendType and VDCommunicationRec.csReplyType values and bits in VDCommunicationInfoRec.csSupportedTypes.*/
enum {
  kVideoNoTransactionType       = 0,    /* No transaction*/
  kVideoSimpleI2CType           = 1,    /* Simple I2C message*/
  kVideoDDCciReplyType          = 2     /* DDC/ci message (with imbedded length)*/
};

/* VDCommunicationRec.csCommFlags and VDCommunicationInfoRec.csSupportedCommFlags*/
enum {
  kVideoReplyMicroSecDelayMask  = (1 << 0) /* If set, the driver should delay csMinReplyDelay micro seconds between send and recieve*/
};



struct VDResolutionInfoRec {
  DisplayModeID       csPreviousDisplayModeID; /* ID of the previous resolution in a chain */
  DisplayModeID       csDisplayModeID;        /* ID of the next resolution */
  unsigned long       csHorizontalPixels;     /* # of pixels in a horizontal line at the max depth */
  unsigned long       csVerticalLines;        /* # of lines in a screen at the max depth */
  Fixed               csRefreshRate;          /* Vertical Refresh Rate in Hz */
  DepthMode           csMaxDepthMode;         /* 0x80-based number representing max bit depth */
  unsigned long       csResolutionFlags;      /* Reserved - flag bits */
  unsigned long       csReserved;             /* Reserved */
};
typedef struct VDResolutionInfoRec      VDResolutionInfoRec;
typedef VDResolutionInfoRec *           VDResolutionInfoPtr;
struct VDVideoParametersInfoRec {
  DisplayModeID       csDisplayModeID;        /* the ID of the resolution we want info on */
  DepthMode           csDepthMode;            /* The bit depth we want the info on (0x80 based) */
  VPBlockPtr          csVPBlockPtr;           /* Pointer to a video parameter block */
  unsigned long       csPageCount;            /* Number of pages supported by the resolution */
  VideoDeviceType     csDeviceType;           /* Device Type:  Direct, Fixed or CLUT; */
  UInt32              csDepthFlags;           /* Flags */
};
typedef struct VDVideoParametersInfoRec VDVideoParametersInfoRec;
typedef VDVideoParametersInfoRec *      VDVideoParametersInfoPtr;
struct VDGammaInfoRec {
  GammaTableID        csLastGammaID;          /* the ID of the previous gamma table */
  GammaTableID        csNextGammaID;          /* the ID of the next gamma table */
  Ptr                 csGammaPtr;             /* Ptr to a gamma table data */
  unsigned long       csReserved;             /* Reserved */
};
typedef struct VDGammaInfoRec           VDGammaInfoRec;
typedef VDGammaInfoRec *                VDGammaInfoPtr;
struct VDGetGammaListRec {
  GammaTableID        csPreviousGammaTableID; /* ID of the previous gamma table */
  GammaTableID        csGammaTableID;         /* ID of the gamma table following csPreviousDisplayModeID */
  unsigned long       csGammaTableSize;       /* Size of the gamma table in bytes */
  char *              csGammaTableName;       /* Gamma table name (c-string) */
};
typedef struct VDGetGammaListRec        VDGetGammaListRec;
typedef VDGetGammaListRec *             VDGetGammaListPtr;
struct VDRetrieveGammaRec {
  GammaTableID        csGammaTableID;         /* ID of gamma table to retrieve */
  GammaTbl *          csGammaTablePtr;        /* Location to copy desired gamma to */
};
typedef struct VDRetrieveGammaRec       VDRetrieveGammaRec;
typedef VDRetrieveGammaRec *            VDRetrieveGammaPtr;
struct VDSetHardwareCursorRec {
  void *              csCursorRef;            /* reference to cursor data */
  UInt32              csReserved1;            /* reserved for future use */
  UInt32              csReserved2;            /* should be ignored */
};
typedef struct VDSetHardwareCursorRec   VDSetHardwareCursorRec;
typedef VDSetHardwareCursorRec *        VDSetHardwareCursorPtr;
struct VDDrawHardwareCursorRec {
  SInt32              csCursorX;              /* x coordinate */
  SInt32              csCursorY;              /* y coordinate */
  UInt32              csCursorVisible;        /* true if cursor is must be visible */
  UInt32              csReserved1;            /* reserved for future use */
  UInt32              csReserved2;            /* should be ignored */
};
typedef struct VDDrawHardwareCursorRec  VDDrawHardwareCursorRec;
typedef VDDrawHardwareCursorRec *       VDDrawHardwareCursorPtr;
struct VDSupportsHardwareCursorRec {
  UInt32              csSupportsHardwareCursor;
                                              /* true if hardware cursor is supported */
  UInt32              csReserved1;            /* reserved for future use */
  UInt32              csReserved2;            /* must be zero */
};
typedef struct VDSupportsHardwareCursorRec VDSupportsHardwareCursorRec;
typedef VDSupportsHardwareCursorRec *   VDSupportsHardwareCursorPtr;
struct VDHardwareCursorDrawStateRec {
  SInt32              csCursorX;              /* x coordinate */
  SInt32              csCursorY;              /* y coordinate */
  UInt32              csCursorVisible;        /* true if cursor is visible */
  UInt32              csCursorSet;            /* true if cursor successfully set by last set control call */
  UInt32              csReserved1;            /* reserved for future use */
  UInt32              csReserved2;            /* must be zero */
};
typedef struct VDHardwareCursorDrawStateRec VDHardwareCursorDrawStateRec;
typedef VDHardwareCursorDrawStateRec *  VDHardwareCursorDrawStatePtr;
struct VDConvolutionInfoRec {
  DisplayModeID       csDisplayModeID;        /* the ID of the resolution we want info on */
  DepthMode           csDepthMode;            /* The bit depth we want the info on (0x80 based) */
  unsigned long       csPage;
  UInt32              csFlags;
  UInt32              csReserved;
};
typedef struct VDConvolutionInfoRec     VDConvolutionInfoRec;
typedef VDConvolutionInfoRec *          VDConvolutionInfoPtr;
struct VDPowerStateRec {
  unsigned long       powerState;
  unsigned long       powerFlags;

  unsigned long       powerReserved1;
  unsigned long       powerReserved2;
};
typedef struct VDPowerStateRec          VDPowerStateRec;
typedef VDPowerStateRec *               VDPowerStatePtr;
/*
    Private Data to video drivers.
    
    In versions of MacOS with multiple address spaces (System 8), the OS 
    must know the extent of parameters in order to move them between the caller
    and driver.  The old private-selector model for video drivers does not have
    this information so:
    
    For post-7.x Systems private calls should be implemented using the cscPrivateCall
*/
struct VDPrivateSelectorDataRec {
  LogicalAddress      privateParameters;      /* Caller's parameters*/
  ByteCount           privateParametersSize;  /* Size of data sent from caller to driver*/
  LogicalAddress      privateResults;         /* Caller's return area. Can be nil, or same as privateParameters.*/
  ByteCount           privateResultsSize;     /* Size of data driver returns to caller. Can be nil, or same as privateParametersSize.*/
};
typedef struct VDPrivateSelectorDataRec VDPrivateSelectorDataRec;

struct VDPrivateSelectorRec {
  UInt32              reserved;               /* Reserved (set to 0). */
  VDPrivateSelectorDataRec  data[1];
};
typedef struct VDPrivateSelectorRec     VDPrivateSelectorRec;
struct VDDDCBlockRec {
  UInt32              ddcBlockNumber;         /* Input -- DDC EDID (Extended Display Identification Data) number (1-based) */
  ResType             ddcBlockType;           /* Input -- DDC block type (EDID/VDIF) */
  UInt32              ddcFlags;               /* Input -- DDC Flags*/
  UInt32              ddcReserved;            /* Reserved */
  Byte                ddcBlockData[128];      /* Output -- DDC EDID/VDIF data (kDDCBlockSize) */
};
typedef struct VDDDCBlockRec            VDDDCBlockRec;
typedef VDDDCBlockRec *                 VDDDCBlockPtr;

enum {
                                        /* timingSyncConfiguration*/
  kSyncInterlaceMask            = (1 << 7),
  kSyncAnalogCompositeMask      = 0,
  kSyncAnalogCompositeSerrateMask = (1 << 2),
  kSyncAnalogCompositeRGBSyncMask = (1 << 1),
  kSyncAnalogBipolarMask        = (1 << 3),
  kSyncAnalogBipolarSerrateMask = (1 << 2),
  kSyncAnalogBipolarSRGBSyncMask = (1 << 1),
  kSyncDigitalCompositeMask     = (1 << 4),
  kSyncDigitalCompositeSerrateMask = (1 << 2),
  kSyncDigitalCompositeMatchHSyncMask = (1 << 2),
  kSyncDigitalSeperateMask      = (1 << 4) + (1 << 3),
  kSyncDigitalVSyncPositiveMask = (1 << 2),
  kSyncDigitalHSyncPositiveMask = (1 << 1)
};



struct VDDisplayTimingRangeRec {
  UInt32              csRangeSize;            /* Init to sizeof(VDDisplayTimingRangeRec) */
  UInt32              csRangeType;            /* Init to 0 */
  UInt32              csRangeVersion;         /* Init to 0 */
  UInt32              csRangeReserved;        /* Init to 0 */

  UInt32              csRangeBlockIndex;      /* Requested block (first index is 0)*/
  UInt32              csRangeGroup;           /* set to 0 */
  UInt32              csRangeBlockCount;      /* # blocks */
  UInt32              csRangeFlags;           /* dependent video */

  UInt64              csMinPixelClock;        /* Min dot clock in Hz */
  UInt64              csMaxPixelClock;        /* Max dot clock in Hz */

  UInt32              csMaxPixelError;        /* Max dot clock error */
  UInt32              csTimingRangeSyncFlags;
  UInt32              csTimingRangeSignalLevels;
  UInt32              csReserved0;

  UInt32              csMinFrameRate;         /* Hz */
  UInt32              csMaxFrameRate;         /* Hz */
  UInt32              csMinLineRate;          /* Hz */
  UInt32              csMaxLineRate;          /* Hz */


  UInt32              csMaxHorizontalTotal;   /* Clocks - Maximum total (active + blanking) */
  UInt32              csMaxVerticalTotal;     /* Clocks - Maximum total (active + blanking) */
  UInt32              csMaxTotalReserved1;    /* Reserved */
  UInt32              csMaxTotalReserved2;    /* Reserved */



                                              /* Some cards require that some timing elements*/
                                              /* be multiples of a "character size" (often 8*/
                                              /* clocks).  The "xxxxCharSize" fields document*/
                                              /* those requirements.*/


  UInt8               csCharSizeHorizontalActive; /* Character size */
  UInt8               csCharSizeHorizontalBlanking; /* Character size */
  UInt8               csCharSizeHorizontalSyncOffset; /* Character size */
  UInt8               csCharSizeHorizontalSyncPulse; /* Character size */

  UInt8               csCharSizeVerticalActive; /* Character size */
  UInt8               csCharSizeVerticalBlanking; /* Character size */
  UInt8               csCharSizeVerticalSyncOffset; /* Character size */
  UInt8               csCharSizeVerticalSyncPulse; /* Character size */

  UInt8               csCharSizeHorizontalBorderLeft; /* Character size */
  UInt8               csCharSizeHorizontalBorderRight; /* Character size */
  UInt8               csCharSizeVerticalBorderTop; /* Character size */
  UInt8               csCharSizeVerticalBorderBottom; /* Character size */

  UInt8               csCharSizeHorizontalTotal; /* Character size for active + blanking */
  UInt8               csCharSizeVerticalTotal; /* Character size for active + blanking */
  UInt16              csCharSizeReserved1;    /* Reserved (Init to 0) */


  UInt32              csMinHorizontalActiveClocks;
  UInt32              csMaxHorizontalActiveClocks;
  UInt32              csMinHorizontalBlankingClocks;
  UInt32              csMaxHorizontalBlankingClocks;

  UInt32              csMinHorizontalSyncOffsetClocks;
  UInt32              csMaxHorizontalSyncOffsetClocks;
  UInt32              csMinHorizontalPulseWidthClocks;
  UInt32              csMaxHorizontalPulseWidthClocks;

  UInt32              csMinVerticalActiveClocks;
  UInt32              csMaxVerticalActiveClocks;
  UInt32              csMinVerticalBlankingClocks;
  UInt32              csMaxVerticalBlankingClocks;

  UInt32              csMinVerticalSyncOffsetClocks;
  UInt32              csMaxVerticalSyncOffsetClocks;
  UInt32              csMinVerticalPulseWidthClocks;
  UInt32              csMaxVerticalPulseWidthClocks;


  UInt32              csMinHorizontalBorderLeft;
  UInt32              csMaxHorizontalBorderLeft;
  UInt32              csMinHorizontalBorderRight;
  UInt32              csMaxHorizontalBorderRight;

  UInt32              csMinVerticalBorderTop;
  UInt32              csMaxVerticalBorderTop;
  UInt32              csMinVerticalBorderBottom;
  UInt32              csMaxVerticalBorderBottom;

  UInt32              csReserved1;            /* Reserved (Init to 0)*/
  UInt32              csReserved2;            /* Reserved (Init to 0)*/
  UInt32              csReserved3;            /* Reserved (Init to 0)*/
  UInt32              csReserved4;            /* Reserved (Init to 0)*/

  UInt32              csReserved5;            /* Reserved (Init to 0)*/
  UInt32              csReserved6;            /* Reserved (Init to 0)*/
  UInt32              csReserved7;            /* Reserved (Init to 0)*/
  UInt32              csReserved8;            /* Reserved (Init to 0)*/
};
typedef struct VDDisplayTimingRangeRec  VDDisplayTimingRangeRec;
typedef VDDisplayTimingRangeRec *       VDDisplayTimingRangePtr;

enum {
                                        /* csDisplayModeState*/
  kDMSModeReady                 = 0,    /* Display Mode ID is configured and ready*/
  kDMSModeNotReady              = 1,    /* Display Mode ID is is being programmed*/
  kDMSModeFree                  = 2     /* Display Mode ID is not associated with a timing*/
};


/* Video driver Errors -10930 to -10959 */
enum {
  kTimingChangeRestrictedErr    = -10930,
  kVideoI2CReplyPendingErr      = -10931,
  kVideoI2CTransactionErr       = -10932,
  kVideoI2CBusyErr              = -10933,
  kVideoI2CTransactionTypeErr   = -10934,
  kVideoBufferSizeErr           = -10935
};


enum {
                                        /* csTimingRangeSignalLevels*/
  kRangeSupportsSignal_0700_0300_Bit = 0,
  kRangeSupportsSignal_0714_0286_Bit = 1,
  kRangeSupportsSignal_1000_0400_Bit = 2,
  kRangeSupportsSignal_0700_0000_Bit = 3,
  kRangeSupportsSignal_0700_0300_Mask = (1 << kRangeSupportsSignal_0700_0300_Bit),
  kRangeSupportsSignal_0714_0286_Mask = (1 << kRangeSupportsSignal_0714_0286_Bit),
  kRangeSupportsSignal_1000_0400_Mask = (1 << kRangeSupportsSignal_1000_0400_Bit),
  kRangeSupportsSignal_0700_0000_Mask = (1 << kRangeSupportsSignal_0700_0000_Bit)
};


enum {
                                        /* csSignalConfig*/
  kDigitalSignalBit             = 0,    /* Do not set.  Mac OS does not currently support arbitrary digital timings*/
  kAnalogSetupExpectedBit       = 1,    /* Analog displays - display expects a blank-to-black setup or pedestal.  See VESA signal standards.*/
  kDigitalSignalMask            = (1 << kDigitalSignalBit),
  kAnalogSetupExpectedMask      = (1 << kAnalogSetupExpectedBit)
};


enum {
                                        /* csSignalLevels for analog*/
  kAnalogSignalLevel_0700_0300  = 0,
  kAnalogSignalLevel_0714_0286  = 1,
  kAnalogSignalLevel_1000_0400  = 2,
  kAnalogSignalLevel_0700_0000  = 3
};


enum {
                                        /* csTimingRangeSyncFlags*/
  kRangeSupportsSeperateSyncsBit = 0,
  kRangeSupportsSyncOnGreenBit  = 1,
  kRangeSupportsCompositeSyncBit = 2,
  kRangeSupportsVSyncSerrationBit = 3,
  kRangeSupportsSeperateSyncsMask = (1 << kRangeSupportsSeperateSyncsBit),
  kRangeSupportsSyncOnGreenMask = (1 << kRangeSupportsSyncOnGreenBit),
  kRangeSupportsCompositeSyncMask = (1 << kRangeSupportsCompositeSyncBit),
  kRangeSupportsVSyncSerrationMask = (1 << kRangeSupportsVSyncSerrationBit)
};



enum {
                                        /* csHorizontalSyncConfig and csVerticalSyncConfig*/
  kSyncPositivePolarityBit      = 0,    /* Digital separate sync polarity for analog interfaces (0 => negative polarity)*/
  kSyncPositivePolarityMask     = (1 << kSyncPositivePolarityBit)
};




/* For timings with kDetailedTimingFormat.*/
struct VDDetailedTimingRec {
  UInt32              csTimingSize;           /* Init to sizeof(VDDetailedTimingRec)*/
  UInt32              csTimingType;           /* Init to 0*/
  UInt32              csTimingVersion;        /* Init to 0*/
  UInt32              csTimingReserved;       /* Init to 0*/

  DisplayModeID       csDisplayModeID;        /* Init to 0*/
  UInt32              csDisplayModeSeed;      /* */
  UInt32              csDisplayModeState;     /* Display Mode state*/
  UInt32              csDisplayModeAlias;     /* Mode to use when programmed.*/

  UInt32              csSignalConfig;
  UInt32              csSignalLevels;

  UInt64              csPixelClock;           /* Hz*/

  UInt64              csMinPixelClock;        /* Hz - With error what is slowest actual clock */
  UInt64              csMaxPixelClock;        /* Hz - With error what is fasted actual clock */


  UInt32              csHorizontalActive;     /* Pixels*/
  UInt32              csHorizontalBlanking;   /* Pixels*/
  UInt32              csHorizontalSyncOffset; /* Pixels*/
  UInt32              csHorizontalSyncPulseWidth; /* Pixels*/

  UInt32              csVerticalActive;       /* Lines*/
  UInt32              csVerticalBlanking;     /* Lines*/
  UInt32              csVerticalSyncOffset;   /* Lines*/
  UInt32              csVerticalSyncPulseWidth; /* Lines*/

  UInt32              csHorizontalBorderLeft; /* Pixels*/
  UInt32              csHorizontalBorderRight; /* Pixels*/
  UInt32              csVerticalBorderTop;    /* Lines*/
  UInt32              csVerticalBorderBottom; /* Lines*/

  UInt32              csHorizontalSyncConfig;
  UInt32              csHorizontalSyncLevel;  /* Future use (init to 0)*/
  UInt32              csVerticalSyncConfig;
  UInt32              csVerticalSyncLevel;    /* Future use (init to 0)*/

  UInt32              csReserved1;            /* Init to 0*/
  UInt32              csReserved2;            /* Init to 0*/
  UInt32              csReserved3;            /* Init to 0*/
  UInt32              csReserved4;            /* Init to 0*/

  UInt32              csReserved5;            /* Init to 0*/
  UInt32              csReserved6;            /* Init to 0*/
  UInt32              csReserved7;            /* Init to 0*/
  UInt32              csReserved8;            /* Init to 0*/
};
typedef struct VDDetailedTimingRec      VDDetailedTimingRec;
typedef VDDetailedTimingRec *           VDDetailedTimingPtr;
typedef UInt32                          VDClutBehavior;
typedef VDClutBehavior *                VDClutBehaviorPtr;
enum {
  kSetClutAtSetEntries          = 0,    /* SetEntries behavior is to update clut during SetEntries call*/
  kSetClutAtVBL                 = 1     /* SetEntries behavior is to upate clut at next vbl*/
};


struct VDCommunicationRec {
  SInt32              csBusID;                /* kVideoDefaultBus for single headed cards.*/
  UInt32              csCommFlags;            /* Always zero*/
  UInt32              csMinReplyDelay;        /* Minimum delay between send and reply transactions (units depend on csCommFlags)*/
  UInt32              csReserved2;            /* Always zero*/

  UInt32              csSendAddress;          /* Usually I2C address (eg 0x6E)*/
  UInt32              csSendType;             /* See kVideoSimpleI2CType etc.*/
  LogicalAddress      csSendBuffer;           /* Pointer to the send buffer*/
  ByteCount           csSendSize;             /* Number of bytes to send*/

  UInt32              csReplyAddress;         /* Address from which to read (eg 0x6F for kVideoDDCciReplyType I2C address)*/
  UInt32              csReplyType;            /* See kVideoDDCciReplyType etc.*/
  LogicalAddress      csReplyBuffer;          /* Pointer to the reply buffer*/
  ByteCount           csReplySize;            /* Max bytes to reply (size of csReplyBuffer)*/

  UInt32              csReserved3;
  UInt32              csReserved4;
  UInt32              csReserved5;            /* Always zero*/
  UInt32              csReserved6;            /* Always zero*/
};
typedef struct VDCommunicationRec       VDCommunicationRec;
typedef VDCommunicationRec *            VDCommunicationPtr;
struct VDCommunicationInfoRec {
  SInt32              csBusID;                /* kVideoDefaultBus for single headed cards. */
  UInt32              csBusType;              /* See kVideoBusI2C etc.*/
  SInt32              csMinBus;               /* Minimum bus (usually kVideoDefaultBus).  Used to probe additional busses*/
  SInt32              csMaxBus;               /* Max bus (usually kVideoDefaultBus).  Used to probe additional busses*/

  UInt32              csSupportedTypes;       /* Bit field for first 32 supported transaction types.  Eg. 0x07 => support for kVideoNoTransactionType, kVideoSimpleI2CType and kVideoDDCciReplyType.*/
  UInt32              csSupportedCommFlags;   /* Return the flags csCommFlags understood by this driver.*/
  UInt32              csReserved2;            /* Always zero*/
  UInt32              csReserved3;            /* Always zero*/

  UInt32              csReserved4;            /* Always zero*/
  UInt32              csReserved5;            /* Always zero*/
  UInt32              csReserved6;            /* Always zero*/
  UInt32              csReserved7;            /* Always zero*/
};
typedef struct VDCommunicationInfoRec   VDCommunicationInfoRec;
typedef VDCommunicationInfoRec *        VDCommunicationInfoPtr;

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
    #pragma pack()
#endif

#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif


#endif /* __VIDEO__ */

